// pages/admin/activation-codes/activation-codes.js
const app = getApp();
const { request } = require('../../../utils/request');
const api = require('../../../utils/api.js');
const codeApi = require('../../../utils/codeApi.js');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    // 统计数据
    statistics: {
      unused_count: 0,
      copied_count: 0,
      exported_count: 0,
      used_count: 0,
      total_count: 0,
      validityOptions: [
        { 'value': '1分', 'label': '1' }
      ]
    },

    // 当前选中的标签页
    activeTab: 'unused',

    // 数据列表
    codesList: [],

    // 分页参数
    page: 1,
    per_page: 5,
    total: 0,

    // 加载状态
    loading: false,
    loadingMore: false,

    // 选择相关
    selectedCodes: [],

    // 模态框
    showActionSheet: false,
    actionSheetItems: [
      { name: '复制激活码', value: 'copy' },
      // { name: '导出激活码', value: 'export' }
    ],
    currentCode: null,

    // 复制状态
    copySuccess: false,

    // 代理信息
    agentInfo: null,
    hasPermission: false,

    // 分值选择
    selectedScore: '全部',
    selectedCount: 0, // 1分对应20次

    // 有效期选择
    validityOptions: [
      { value: '7days', label: '7天' },
      { value: '30days', label: '30天' },
      { value: '90days', label: '90天' },
      { value: 'forever', label: '永久' }
    ],
    selectedValidity: '30days'
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 首先检查代理权限
    this.checkAgentPermission(() => {
      this.getStatistics();
      this.loadCodes();

      // 如果传入了特定标签页，则切换到该标签页
      if (options.tab && ['unused', 'copied', 'exported', 'used'].includes(options.tab)) {
        this.setData({
          activeTab: options.tab
        });
      }

      // 如果传入了分值，则设置分值
      if (options.score) {
        this.handleScoreFromOptions(options.score);
      }

      // 初始化创建激活码页面路径
      this.refreshCreateCodePath();
    });
  },

  toCodeQuery(){
    wx.navigateTo({
      url: '/pages/admin/code-query/index',
    })
  },
  /**
   * 检查代理权限
   */
  checkAgentPermission(callback) {
    // 确保用户ID存在
    const userId = wx.getStorageSync('userId');

    if (!userId) {
      wx.showModal({
        title: '提示',
        content: '未登录或登录已过期，请先登录',
        showCancel: false,
        success: () => {
          wx.navigateTo({
            url: '/pages/login/login'
          });
        }
      });
      return;
    }

    // 使用专用API检查权限
    codeApi.checkPermission(userId)
      .then(res => {
        if (res.code === 0 && res.data && res.data.has_permission) {
          // 保存代理信息
          this.setData({
            hasPermission: true,
            agentInfo: res.data.agent_info || {}
          });

          if (callback && typeof callback === 'function') {
            callback();
          }
        } else {
          // 没有权限
          wx.showModal({
            title: '提示',
            content: '您暂无卡密管理权限',
            showCancel: false,
            success: () => {
              wx.navigateBack();
            }
          });
        }
      })
      .catch(err => {
        console.error('检查权限失败', err);

        wx.showToast({
          title: '网络错误',
          icon: 'none',
          success: () => {
            setTimeout(() => {
              wx.navigateBack();
            }, 1500);
          }
        });
      });
  },

  /**
   * 获取统计数据
   */
  getStatistics() {
    this.setData({
      statistics: {
        unused_count: 0,
        copied_count: 0,
        exported_count: 0,
        used_count: 0,
        total_count: 0
      }
    });

    // 获取代理ID
    const agentId = this.data.agentInfo ? this.data.agentInfo.id : null;

    // 使用专用API获取统计
    codeApi.getCodesStatistics(agentId)
      .then(res => {
        if (res.code === 0) {
          // 确保统计数据中的所有字段都存在
          const stats = {
            unused_count: res.data.unused_count || 0,
            copied_count: res.data.copied_count || 0,
            exported_count: res.data.exported_count || 0,
            used_count: res.data.used_count || 0,
            total_count: res.data.total_count || 0
          };

          this.setData({
            statistics: stats
          });
        } else {
          wx.showToast({
            title: res.message || '获取统计数据失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });
      });
  },

  /**
   * 加载激活码列表
   */
  loadCodes(refresh = true) {
    // 如果正在加载中，避免重复请求
    if (this.data.loading || this.data.loadingMore) {
      return;
    }

    if (refresh) {
      this.setData({
        page: 1,
        codesList: [],
        loading: true,
        selectedCodes: [] // 刷新列表时清空选中项
      });
    } else {
      // 检查是否已经加载完所有数据
      if (this.data.codesList.length >= this.data.total) {
        this.setData({
          loadingMore: false
        });
        return;
      }

      this.setData({
        loadingMore: true
      });
    }

    // 根据当前标签页设置查询参数
    let params = {
      page: this.data.page,
      per_page: this.data.per_page
    };

    // 添加代理ID过滤
    if (this.data.agentInfo && this.data.agentInfo.id) {
      params.agent_id = this.data.agentInfo.id;
    }

    // 添加分值/使用次数过滤
    if (this.data.selectedCount) {
      params.usage_count = this.data.selectedCount;
    }

    switch (this.data.activeTab) {
      case 'unused':
        params.status = 0;  // 未使用
        // 添加排序字段，未导出和未复制的排在前面
        params.sort_by = 'priority';
        break;
      case 'copied':
        params.is_copied = 1;  // 已复制
        params.sort_by = 'copied_time';
        params.sort_order = 'desc';  // 最近复制的排前面
        break;
      case 'exported':
        params.is_exported = 1;  // 已导出
        params.sort_by = 'exported_time';
        params.sort_order = 'desc';  // 最近导出的排前面
        break;
      case 'used':
        params.status = 1;  // 已使用
        params.sort_by = 'used_time';
        params.sort_order = 'desc';  // 最近使用的排前面
        break;
    }

    // 调用激活码列表API
    codeApi.getActivationCodes(params)
      .then(res => {
        if (res.code === 0) {
          const newData = res.data || {};
          let items = newData.items || [];

          // 如果是未使用的标签页，对返回数据进行二次排序
          if (this.data.activeTab === 'unused') {
            // 对数据进行排序处理：未导出未复制 > 已复制未导出 > 已导出
            items = this.sortActivationCodes(items);
          }

          // 更新列表数据
          if (refresh) {
            this.setData({
              codesList: items,
              total: newData.total || 0,
              loading: false
            });
          } else {
            this.setData({
              codesList: [...this.data.codesList, ...items],
              loadingMore: false
            });
          }

          if (refresh) {
            // 停止下拉刷新
            wx.stopPullDownRefresh();
          }
        } else {
          // 请求失败
          this.setData({
            loading: false,
            loadingMore: false
          });

          wx.showToast({
            title: res.message || '获取数据失败',
            icon: 'none'
          });

          // 停止下拉刷新
          wx.stopPullDownRefresh();
        }
      })
      .catch(err => {
        console.error('获取激活码列表失败', err);

        this.setData({
          loading: false,
          loadingMore: false
        });

        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });

        // 停止下拉刷新
        wx.stopPullDownRefresh();
      });
  },

  /**
   * 对激活码列表进行排序
   * 优先级：未导出未复制 > 已复制未导出 > 已导出
   */
  sortActivationCodes(codes) {
    if (!codes || codes.length === 0) return [];

    return codes.sort((a, b) => {
      // 计算优先级分数，分数越低优先级越高
      const scoreA = (a.is_copied ? 1 : 0) + (a.is_exported ? 2 : 0);
      const scoreB = (b.is_copied ? 1 : 0) + (b.is_exported ? 2 : 0);

      // 首先按优先级排序
      if (scoreA !== scoreB) {
        return scoreA - scoreB;
      }

      // 如果优先级相同，按创建时间倒序排列（新的排在前面）
      const timeA = new Date(a.create_time).getTime();
      const timeB = new Date(b.create_time).getTime();
      return timeB - timeA;
    });
  },

  /**
   * 切换标签页
   */
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    if (tab !== this.data.activeTab) {
      this.setData({
        activeTab: tab,
        selectedCodes: []  // 切换标签时清空选择
      }, () => {
        this.loadCodes();
      });
    }
  },
  onScoreInput(e) {
    this.setData({
      selectedCount: e.detail.value,
      selectedCodes: [],
      selectedScore:null,
    })
    this.loadCodes();
  },
  /**
   * 显示操作菜单
   */
  showActionMenu(e) {
    // 确保索引有效
    const index = e.currentTarget.dataset.index;
    if (index === undefined || !this.data.codesList || index >= this.data.codesList.length) {
      return;
    }

    const code = this.data.codesList[index];

    // 根据状态动态设置菜单选项
    let actionItems = [];

    // 复制选项总是可用
    actionItems.push({ name: '复制激活码', value: 'copy' });

    // // 只有未导出的才显示导出选项
    // if (!code.is_exported) {
    //   actionItems.push({ name: '导出激活码', value: 'export' });
    // }

    this.setData({
      currentCode: code,
      actionSheetItems: actionItems,
      showActionSheet: true
    });
  },

  /**
   * 关闭操作菜单
   */
  closeActionSheet() {
    this.setData({
      showActionSheet: false
    });
  },

  /**
   * 处理操作菜单选择
   */
  handleActionClick(e) {
    const action = e.detail;
    this.closeActionSheet();

    if (!this.data.currentCode) {
      console.error('当前选中的激活码为空');
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      });
      return;
    }

    console.log('选择操作:', action, '当前激活码:', this.data.currentCode);

    // 根据选择执行不同操作
    switch (action.value) {
      case 'copy':
        this.copyCode(this.data.currentCode);
        break;
      case 'export':
        this.markAsExported(this.data.currentCode.id);
        break;
      default:
        console.warn('未知操作:', action);
    }
  },

  /**
   * 复制激活码
   */
  copyCode(code) {
    wx.setClipboardData({
      data: code.code,
      success: () => {
        // 标记为已复制
        this.markAsCopied(code.id);

        this.setData({
          copySuccess: true
        });

        // 2秒后隐藏成功提示
        setTimeout(() => {
          this.setData({
            copySuccess: false
          });
        }, 2000);
      },
      fail: (err) => {
        console.error('复制失败:', err);
        wx.showToast({
          title: '复制失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 标记为已复制
   */
  markAsCopied(codeId) {
    console.log('标记为已复制:', codeId);


    codeApi.markAsCopied(codeId)
      .then(res => {
        console.log('标记结果:', res);

        if (res.code === 0) {
          // 更新本地数据
          this.updateCodeStatus(codeId, { is_copied: true, copied_time: res.data.copied_time });
          // 更新统计数据
          this.getStatistics();
        } else {
          wx.showToast({
            title: res.message || '标记失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('标记为已复制失败', err);

        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });
      });
  },

  /**
   * 标记为已导出
   */
  markAsExported(codeId) {
    console.log('标记为已导出:', codeId);

    // 显示加载中
    wx.showLoading({
      title: '标记中...',
      mask: true
    });

    codeApi.markAsExported(codeId)
      .then(res => {
        wx.hideLoading();
        console.log('标记结果:', res);

        if (res.code === 0) {
          // 更新本地数据
          this.updateCodeStatus(codeId, { is_exported: true, exported_time: res.data.exported_time });
          // 更新统计数据
          this.getStatistics();
          // 刷新列表
          this.loadCodes();

          wx.showToast({
            title: '已标记为导出',
            icon: 'success'
          });
        } else {
          wx.showToast({
            title: res.message || '标记失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        wx.hideLoading();
        console.error('标记为已导出失败', err);

        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });
      });
  },

  /**
   * 更新代码状态
   */
  updateCodeStatus(codeId, statusUpdate) {
    const { codesList } = this.data;
    const index = codesList.findIndex(code => code.id === codeId);

    if (index !== -1) {
      const updatedCodes = [...codesList];
      updatedCodes[index] = { ...updatedCodes[index], ...statusUpdate };

      this.setData({
        codesList: updatedCodes
      });
    }
  },

  /**
   * 选择/取消选择激活码
   */
  toggleSelect(e) {
    const index = e.currentTarget.dataset.index;
    const code = this.data.codesList[index];
    const { selectedCodes } = this.data;

    const isSelected = selectedCodes.some(item => item.id === code.id);

    if (isSelected) {
      // 取消选择
      this.setData({
        selectedCodes: selectedCodes.filter(item => item.id !== code.id)
      });
    } else {
      // 选择
      this.setData({
        selectedCodes: [...selectedCodes, code]
      });
    }
  },

  /**
   * 全选/取消全选
   */
  toggleSelectAll() {
    if (this.data.selectedCodes.length === this.data.codesList.length) {
      // 取消全选
      this.setData({
        selectedCodes: []
      });
    } else {
      // 全选
      this.setData({
        selectedCodes: [...this.data.codesList]
      });
    }
  },

  /**
   * 批量复制
   */
  batchCopy() {
    const { selectedCodes } = this.data;

    if (!selectedCodes || selectedCodes.length === 0) {
      wx.showToast({
        title: '请先选择激活码',
        icon: 'none'
      });
      return;
    }

    // 复制所有选中的激活码
    const codeTexts = selectedCodes.map(code => code.code).join('\n');

    wx.setClipboardData({
      data: codeTexts,
      success: () => {
        // 标记所有选中的激活码为已复制
        const codeIds = selectedCodes.map(code => code.id);

        codeApi.batchMarkCopied(codeIds)
          .then(res => {
            if (res.code === 0) {
              // 刷新列表和统计
              this.getStatistics();
              this.loadCodes();
            } else {
              wx.showToast({
                title: res.message || '操作失败',
                icon: 'none'
              });
            }
          })
          .catch(() => {
            wx.showToast({
              title: '网络错误',
              icon: 'none'
            });
          });
      },
      fail: () => {
        wx.showToast({
          title: '复制失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 批量导出
   */
  batchExport() {
    const { selectedCodes } = this.data;
    wx.navigateTo({
      url: '/pages/admin/batchExport/index',
    })


    return
    if (!selectedCodes || selectedCodes.length === 0) {
      wx.showToast({
        title: '请先选择激活码',
        icon: 'none'
      });
      return;
    }

    // 标记所有选中的激活码为已导出
    const codeIds = selectedCodes.map(code => code.id);

    codeApi.batchMarkExported(codeIds)
      .then(res => {
        if (res.code === 0) {
          wx.showToast({
            title: '导出成功',
            icon: 'success'
          });

          // 刷新列表和统计
          this.getStatistics();
          this.loadCodes();
        } else {
          wx.showToast({
            title: res.message || '导出失败',
            icon: 'none'
          });
        }
      })
      .catch(() => {
        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });
      });
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    if (!this.data.loading && !this.data.loadingMore && this.data.codesList.length < this.data.total) {
      this.setData({
        page: this.data.page + 1
      }, () => {
        this.loadCodes(false);
      });
    }
  },

  /**
   * 下拉刷新
   */
  onPullDownRefresh() {
    this.getStatistics();
    this.loadCodes();
    wx.stopPullDownRefresh();
  },

  /**
   * 跳转到生成激活码页面
   */
  goToCreateCode() {
    // 确保路径已刷新
    this.refreshCreateCodePath();

    wx.navigateTo({
      url: this.createCodePath
    });
  },

  /**
   * 直接复制激活码（通过按钮）
   */
  directCopy(e) {
    const index = e.currentTarget.dataset.index;
    if (index === undefined || !this.data.codesList || index >= this.data.codesList.length) {
      return;
    }

    const code = this.data.codesList[index];
    console.log('直接复制:', code);
    this.copyCode(code);
  },

  /**
   * 直接标记为已导出（通过按钮）
   */
  directExport(e) {
    const index = e.currentTarget.dataset.index;
    if (index === undefined || !this.data.codesList || index >= this.data.codesList.length) {
      return;
    }

    const code = this.data.codesList[index];
    console.log('直接标记导出:', code);
    this.markAsExported(code.id);
  },

  /**
   * 处理URL参数中的分值
   */
  handleScoreFromOptions(score) {
    let selectedScore = '1分';
    let selectedCount = 20;

    switch (score) {
      case '1':
        selectedScore = '1分';
        selectedCount = 20;
        break;
      case '3':
        selectedScore = '3分';
        selectedCount = 60;
        break;
      case '6':
        selectedScore = '6分';
        selectedCount = 120;
        break;
      case 'forever':
        selectedScore = '永久';
        selectedCount = 99999;
        break;
    }

    this.setData({
      selectedScore,
      selectedCount
    });
  },

  /**
   * 切换分值选择
   */
  changeScore(e) {
    const { score, count } = e.currentTarget.dataset;

    this.setData({
      selectedScore: score,
      selectedCount: parseInt(count)
    });

    // 刷新创建激活码页面路径
    this.refreshCreateCodePath();

    // 重新加载对应分值的数据
    this.getStatistics();
    this.loadCodes();

    wx.showToast({
      title: `已选择${score}`,
      icon: 'none'
    });
  },

  /**
   * 刷新创建激活码页面路径 
   */
  refreshCreateCodePath() {
    // 这里可以添加其他需要传递的参数
    this.createCodePath = `/pages/admin/create-activation-code/create-activation-code?score=${this.data.selectedScore}&count=${this.data.selectedCount}`;
  },

  /**
   * 有效期变更
   */
  changeValidity(e) {
    this.setData({
      selectedValidity: e.detail.value
    });
  },
})